

#include <iostream>
#include <map>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

class Solution
{
public:
    bool isUnique1(string astr)
    {
        int cnt[26] = { 0 };

        for (const auto& e : astr)
        {
            ++cnt[e - 'a'];
        }
        for (const auto& e : cnt)
        {
            if (e > 1)
                return false;
        }

        return true;
    }

    bool isUnique2(string astr)
    {
        int sz = astr.size();

        if (sz > 26)
            return false;

        int bitMap = 0;
        for (const auto& e : astr)
        {
            int index = e - 'a';

            if ((bitMap >> index) & 1U)
                return false;
            bitMap |= 1U << index;
        }

        return true;
    }

    int missingNumber1(vector<int>& nums)
    {
        int ans = 0;

        for (const auto& e : nums)
        {
            ans ^= e;
        }
        for (int i = 0; i <= nums.size(); ++i)
        {
            ans ^= i;
        }

        return ans;
    }

    int missingNumber2(vector<int>& nums)
    {
        int sum = 0;

        for (int i = 0; i <= nums.size(); ++i)
        {
            sum += i;
        }
        for (const auto& e : nums)
        {
            sum -= e;
        }

        return sum;
    }

    int missingNumber3(vector<int>& nums)
    {
        int sum = nums.size() * (nums.size() + 1) >> 1;

        for (const auto& e : nums)
        {
            sum -= e;
        }

        return sum;
    }

    int missingNumber4(vector<int>& nums)
    {
        sort(nums.begin(), nums.end());

        int ans = 0;
        int sz = nums.size();

        if (nums[sz - 1] == sz - 1)
            return sz;

        for (int i = 0; i < sz; ++i)
        {
            if (nums[i] != i)
            {
                ans = i;
                break;
            }
        }

        return ans;
    }

    int getSum(int a, int b)
    {
        while (b)
        {
            int carry = (a & b) << 1;
            a = a ^ b;
            b = carry;
        }

        return a;
    }

    int singleNumber1(vector<int>& nums)
    {
        int ans = 0;
        int sz = nums.size();

        for (int i = 0; i < sz; ++i)
        {
            int cnt = 1;
            for (int j = 0; j < sz; ++j)
            {
                if (nums[i] == nums[j] && i != j)
                    ++cnt;
            }

            if (cnt == 1)
            {
                ans = nums[i];
                break;
            }
        }

        return ans;
    }

    int singleNumber2(vector<int>& nums)
    {
        int ans = 0;
        map<int, int> Map;

        for (const auto& e : nums)
        {
            ++Map[e];
        }
        for (const auto& e : Map)
        {
            if (Map.count(e.first) == 1)
            {
                ans = e.first;
                break;
            }
        }

        return ans;
    }

    int singleNumber3(vector<int>& nums)
    {
        int ans = 0;
        map<int, int> Map;

        for (const auto& e : nums)
        {
            ++Map[e];
        }
        vector<pair<int, int>> v(Map.begin(), Map.end());
        sort(v.begin(), v.end(), comp());

        return v.begin()->first;
    }

    int singleNumber4(vector<int>& nums)
    {
        int ans = 0;

        for (int i = 0; i < 32; ++i)
        {
            int sum = 0;

            for (const auto& e : nums)
            {
                sum += (e >> i) & 1U;
            }
            sum %= 3;

            if (sum)
                ans |= sum << i;
        }

        return ans;
    }

    vector<int> missingTwo(vector<int>& nums)
    {
        int xorsum = 0;
        int sz = nums.size();

        for (const auto& e : nums)
        {
            xorsum ^= e;
        }
        for (int i = 1; i <= sz + 2; ++i)
        {
            xorsum ^= i;
        }

        int bit1 = 0;
        for (int i = 0; i < 32; ++i)
        {
            if ((xorsum >> i) & 1U)
            {
                bit1 = i;
                break;
            }
        }

        int a = 0, b = 0;
        for (const auto& e : nums)
        {
            if ((e >> bit1) & 1U)
                a ^= e;
            else
                b ^= e;
        }
        for (int i = 1; i <= sz + 2; ++i)
        {
            if ((i >> bit1) & 1U)
                a ^= i;
            else
                b ^= i;
        }

        return { a, b };
    }
private:
    struct comp
    {
        bool operator()(const pair<int, int>& x, const pair<int, int>& y)
        {
            return x.second < y.second;
        }
    };
};

int main()
{
    cout << (2 xor 3) << endl;

	return 0;
}